/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package ifpb.pod.cliente.funcionalidades;

import ifpb.pod.cliente.visao.GUIConversa;
import ifpb.pod.cliente.visao.GUITook;
import ifpb.pod.model.ContaUsuario;
import ifpb.pod.model.Contato;
import ifpb.pod.model.Noticia;
import ifpb.pod.model.Usuario;
import ifpb.pod.registro.Registro;
import ifpb.pod.remote.ClienteRemote;
import ifpb.pod.remote.ServidorRemote;
import java.net.MalformedURLException;
import java.rmi.AccessException;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author Diogenes
 */
public class FachadaCliente {

    private ServidorRemote servidor;
    private GUITook took;
    private static FachadaCliente instance = null;

    private FachadaCliente() {
        instancia();
    }

    public static FachadaCliente getInstance() {
        if (instance == null) {
            instance = new FachadaCliente();
        }
        return instance;
    }

    public void instancia() {
        try {
            try {
                //            this.registro = new Registro();
                //                    LocateRegistry.getRegistry("localhost", 10790);
                this.servidor = (ServidorRemote) Registro.lookup("facadaServidor");
            } catch (MalformedURLException ex) {
                Logger.getLogger(FachadaCliente.class.getName()).log(Level.SEVERE, null, ex);
            }
        } catch (NotBoundException ex) {
            ex.printStackTrace();
        } catch (AccessException ex) {
            ex.printStackTrace();
        } catch (RemoteException ex) {
            ex.printStackTrace();
        }
    }

    public Boolean cadastrarUsuario(Usuario usuario) {
        Boolean retorno = false;
        try {
            retorno = this.servidor.cadastrarUsuario(usuario);
        } catch (RemoteException ex) {
            ex.printStackTrace();
        }
        return retorno;
    }

    public Boolean autenticarUsuario(ContaUsuario conta) {
        Boolean retorno = false;
        try {
            retorno = this.servidor.autenticarUsuario(conta);
        } catch (RemoteException ex) {
            ex.printStackTrace();
        }
        return retorno;
    }

    public void desautenticar(ContaUsuario contaUsuario) {
        try {
            this.servidor.desautenticar(contaUsuario);
        } catch (RemoteException ex) {
            ex.printStackTrace();
        }
    }

    public Usuario buscarUsuario(ContaUsuario conta) {
        Usuario retorno = null;
        try {
            retorno = this.servidor.buscarUsuario(conta);
        } catch (RemoteException ex) {
            ex.printStackTrace();
        }
        return retorno;

    }

    public Usuario addAmigoContato(Usuario usuario, String login) {
        Usuario retorno = usuario;
        try {
            retorno = this.servidor.addAmigoContato(usuario, login);
        } catch (RemoteException ex) {
            ex.printStackTrace();
        }
        return retorno;
    }

    public List<Contato> getAmigosOnline(Usuario usuario) {
        List<Contato> retorno = new ArrayList<Contato>();
        try {
            retorno = this.servidor.getContatosOnline(usuario);
        } catch (RemoteException ex) {
            ex.printStackTrace();
        }
        return retorno;
    }

    public void abrirJanelaPrincipal(Usuario u, ClienteRemote cliente) {
        try {
            try {
                //coloquei antes dos dois proximos
                Registro.rebind(u.getContaUsuario().getLogin(), cliente);
            } catch (AccessException ex) {
                Logger.getLogger(FachadaCliente.class.getName()).log(Level.SEVERE, null, ex);
            } catch (MalformedURLException ex) {
                Logger.getLogger(FachadaCliente.class.getName()).log(Level.SEVERE, null, ex);
            }
            this.took = new GUITook(u);
            this.took.setVisible(true);
            System.out.println("Usuario registrado e online...");
        } catch (RemoteException ex) {
            ex.printStackTrace();
        }
    }

    public void conversar(Contato remetente, Contato destinatario) {
        try {
            servidor.conversar(remetente, destinatario);
        } catch (RemoteException ex) {
            ex.printStackTrace();
        }
    }

    public void notificaStatusUsuario() {
        System.out.println("Entrei na notficação");
        Usuario u = buscarUsuario(took.getUsuario().getContaUsuario());
        System.out.println(u.getNome() + "falooo");
        took.atualizaUsuario(u);
    }

    public void solicitarConversaGrupo(Contato remetente, Contato convidado, List<Contato> contatosDaConversa, Boolean mediador) throws RemoteException {
        System.out.println("------------------Só na gambiarra-------------------");
        ArmazemDeConversas armazem = ArmazemDeConversas.getInstance();
//        GUIConversa conversa = armazem.getConversaGambiarra(contatosDaConversa);
//        System.out.println(conversa + "conv1");
        GUIConversa retornoConversa = armazem.removeConversaGambiarra(contatosDaConversa);
  
//        if (retornoConversa != null) {
            ClienteRemote cliente = this.servidor.solicitaConversaGrupo(remetente, convidado, contatosDaConversa);
           retornoConversa.addClienteRemoto(cliente);
            String key = retornoConversa.getKeyConversas();
            armazem.adicionaConversa(key, retornoConversa);
            System.out.println("-------------------------------------");
//        }

    }

    public void conversarGrupo(Contato remetente, Contato convidado, List<Contato> contatosDaConversa, Boolean mediador) {
        try {
            servidor.conversarGrupo(remetente, convidado, contatosDaConversa,mediador);
        } catch (RemoteException ex) {
            ex.printStackTrace();
        }
    }

    public void notificarNoticia(){
        this.took.notificarNoticiaChegou();
    }

    public List<Noticia> getNoticias(Usuario u) {
        List<Noticia> noticias = null;
        try {
            noticias = this.servidor.getNoticiasUsuario(u);
        } catch (RemoteException ex) {
            ex.printStackTrace();
        }
        return noticias;
    }
}
